Hide

SftTabs/DLL 6.5 - Tab Control

Display
Print

Features 1 Sample (C++/MFC)

This sample illustrates a background bitmap (outside tab control) and owner-draw tabs.

The source code is located at C:\Program Files (x86)\Softelvdm\SftTabs DLL 6.5\Samples\MFC\Features 1\SampleDlg.cpp or C:\Program Files\Softelvdm\SftTabs DLL 6.5\Samples\MFC\Features 1\SampleDlg.cpp (on 32-bit Windows versions).

/****************************************************************************/
/* SftTabs/DLL 6.5 - Tab Control for C/C++                                  */
/* Copyright (C) 1994, 2017  Softel vdm, Inc. All Rights Reserved.          */
/****************************************************************************/

#include "stdafx.h"
#include "Features1.h"
#include "SampleDlg.h"

#include "Page1.h"
#include "Page2.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/*- Tab Control Initialization Data --------------------------------------------*/

static const SFTTABS_CONTROL CtlInit = {
    SFTTABSSTYLE_MODERN_I,               /* tab style */
    1,                                   /* number of rows */
    0,                                   /* number of tabs per row (if fFixed) */
    15,                                  /* width of left margin */
    10,                                  /* width of right margin */
    FALSE,                               /* same width for all tabs */
    TRUE,                                /* Client area wanted */
    FALSE,                               /* allow multiline label text */
    TRUE,                                /* use with dialog */
    FALSE,                               /* use specified background color only for text */
    FALSE,                               /* scrollable tabs */
    FALSE,                               /* hide scroll buttons */
    FALSE,                               /* bold font for active tab wanted */
    FALSE,                               /* fill rows completely */
    NULL,                                /* scroll button bitmap */
    NULL,                                /* Dialog data associated with active tab */
    NULL,                                /* Dialog window handle associated with active tab */
    NULL,                                /* Frame, used as client area */
    TRUE,                                /* Tooltips wanted */
    FALSE,                               /* drop text if it doesn't fit */
    FALSE,                               /* conditional scroll buttons */
    BMBUTTONSTYLE_STD,                   /* scroll button style */
    TRUE,                                /* display ... if truncated */
    TRUE,                                /* Flyby highlighting */
    TRUE,                                /* use client area colors in partially obscured frames */
    FALSE,                               /* scroll buttons on left side */
    -1,                                  /* row indentation */
    FALSE,                               /* don't show truncated pattern for clipped tab */
    FALSE,                               /* full size scroll buttons */
    TRUE,                                /* use themes on Windows XP */
    TRUE,                                /* use exact window region */
    FALSE,                               /* always show prefix _ */
    0,0,0,0,                             /* animation values */
    NULL,                                /* disabled button bitmap */
    TRUE,                                /* focus rectangle if the control has i/p focus */
    FALSE,                               /* TRUE if Close button wanted */
    FALSE,                               /* TRUE if Close button disabled */
    FALSE,                               /* TRUE if WM_CLOSE message wanted */
    FALSE,                               /* TRUE if Minimize, Restore, Close buttons are full size */
    SFTTABS_BUTTON_NEAR,                 /* scroll button alignment */
    SFTTABS_BUTTON_NEAR,                 /* Minimize, Restore, Close button alignment */
    FALSE,                               /* TRUE if Minimize button wanted */
    FALSE,                               /* TRUE if Minimize button disabled */
    FALSE,                               /* TRUE if Restore button wanted */
    FALSE,                               /* TRUE if Restore button disabled */
    NULL,                                /* Close, Minimize, Restore button bitmap */
    NULL,                                /* Close, Minimize, Restore disabled button bitmap */
    TEXT(""),                            /* scroll left button tooltip */
    TEXT(""),                            /* scroll button tooltip */
    TEXT(""),                            /* Close button tooltip */
    TEXT(""),                            /* Minimize button tooltip */
    TEXT(""),                            /* Restore button tooltip */
    0,                                   /* custom modifications */
    0,                                   /* forced height/width depending on tab style - 0 to ignore */
    FALSE,                               /* switch tabs on button release (or down if FALSE) */
    FALSE,                               /* Rendering compatible with pre-6.0 */
    FALSE,                               /* don't display clientarea border - select styles only */
    SFTTABS_TABS_LEFT,                   /* alignment of tabs on all rows */
    SFTTABS_LAYOUT_DISTRIBUTE,           /* distribution of tabs on rows */
    0, 0,                                /* minimum and maximum number of rows for autoflow layout (none specified) */
    FALSE,                               /* reorderable tabs */
    FALSE,                               /* drag & drop */
};

static const SFTTABS_TAB Tab0 = {   /*&{linksame "Background" g_background} */
    SFTTABS_NOCOLOR, SFTTABS_NOCOLOR,    /* background, foreground color */
    SFTTABS_NOCOLOR, SFTTABS_NOCOLOR,    /* background, foreground color (when selected) */
    { SFTTABS_GRAPH_NONE, 0 },           /* location */
    TRUE,                                /* enabled/disabled */
    0,                                   /* userdata */
    0,                                   /* reserved */
    NULL,                                /* reserved */
    SFTTABS_NOCOLOR,                     /* Flyby foreground color */
    SFTTABS_NOCOLOR,                     /* Client area background color */
    0,0,0,0,                             /* animation values */
    NULL,                                /* tab-specific ImageList handle*/
    FALSE,                               /* hidden tab */
    SFTTABS_NOCOLOR,                     /* gradient fill background color */
    SFTTABS_NOCOLOR, 
    SFTTABS_NOCOLOR,                     /* gradient fill background color, active tab */
    SFTTABS_NOCOLOR, 
    SFTTABS_NOCOLOR,                     /* gradient fill client area color */
    SFTTABS_NOCOLOR, 
    0,0,0,                         /* TabPicture, TabPictureDisabled and TabPictureHot */
    FALSE,                               /* has tab close button */
    0,0,0,0,0,                   /* gap2, TabPicture2, TabPicture2Active, TabPicture2Disabled, TabPicture2Hot */
};
static const SFTTABS_TAB Tab1 = {   /*&Ownerdraw */
    SFTTABS_NOCOLOR, SFTTABS_NOCOLOR,    /* background, foreground color */
    SFTTABS_NOCOLOR, SFTTABS_NOCOLOR,    /* background, foreground color (when selected) */
    { SFTTABS_GRAPH_NONE, 0 },           /* location */
    TRUE,                                /* enabled/disabled */
    0,                                   /* userdata */
    0,                                   /* reserved */
    NULL,                                /* reserved */
    SFTTABS_NOCOLOR,                     /* Flyby foreground color */
    SFTTABS_NOCOLOR,                     /* Client area background color */
    0,0,0,0,                             /* animation values */
    NULL,                                /* tab-specific ImageList handle*/
    FALSE,                               /* hidden tab */
    SFTTABS_NOCOLOR,                     /* gradient fill background color */
    SFTTABS_NOCOLOR, 
    SFTTABS_NOCOLOR,                     /* gradient fill background color, active tab */
    SFTTABS_NOCOLOR, 
    SFTTABS_NOCOLOR,                     /* gradient fill client area color */
    SFTTABS_NOCOLOR, 
    0,0,0,                         /* TabPicture, TabPictureDisabled and TabPictureHot */
    FALSE,                               /* has tab close button */
    0,0,0,0,0,                   /* gap2, TabPicture2, TabPicture2Active, TabPicture2Disabled, TabPicture2Hot */
};

/////////////////////////////////////////////////////////////////////////////
// CSampleDlg dialog

CSampleDlg::CSampleDlg(CWnd* pParent /*=NULL*/)
    : CSftTabsDialog(CSampleDlg::IDD, pParent)
{
    //{{AFX_DATA_INIT(CSampleDlg)
        // NOTE: the ClassWizard will add member initialization here
    //}}AFX_DATA_INIT
    // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    m_BgBitmap.LoadBitmap(IDB_LOGO);
}

void CSampleDlg::DoDataExchange(CDataExchange* pDX)
{
    CSftTabsDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CSampleDlg)
        // NOTE: the ClassWizard will add DDX and DDV calls here
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSampleDlg, CSftTabsDialog)
    //{{AFX_MSG_MAP(CSampleDlg)
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSampleDlg message handlers

BOOL CSampleDlg::OnInitDialog()
{
    CSftTabsDialog::OnInitDialog();

    // Set the icon for this dialog.  The framework does this automatically
    //  when the application's main window is not a dialog
    SetIcon(m_hIcon, TRUE);         // Set big icon
    SetIcon(m_hIcon, FALSE);        // Set small icon
    
    int index;

    /* Associate the tab control created from the dialog       */
    /* resource with the C++ object.                           */
    m_Tab.SubclassDlgItem(IDC_TAB, this /* parent window */);

    /* You could use DDX/DDV instead and add the following     */
    /* line to the DoDataExchange function of the tab          */
    /* control's parent window (remove the //).                */
    // DDX_Control(pDX, IDC_TAB, m_Tab);

    /* Initialization is faster if we set redraw off */
    m_Tab.SetRedraw(FALSE);

    /* We are using new features */
    m_Tab.SetVersion(SFTTABS_6_5);

    index = m_Tab.AddTab(_T("&Background"));
    m_Tab.SetToolTip(index, _T("About Background Bitmaps..."));
    m_Tab.SetTabInfo(index, &Tab0);
    m_Tab.SetTabDialog(index, new CPage1(this));

    index = m_Tab.AddTab(_T("&Ownerdraw"));
    m_Tab.SetToolTip(index, _T("About Owner-Draw Tabs..."));
    m_Tab.SetTabInfo(index, &Tab1);
    m_Tab.SetTabDialog(index, new CPage2(this));

    m_Tab.SetControlInfo(&CtlInit);

    // Register a drawing callback
    {
        SFTTABS_DRAWPROCPARM Parm = {
            CSampleDlg::DrawOneTabCallback,
            (SFTTABS_DWORD_PTR)(LPVOID)this // Pass this to callback as UserData
        };
        m_Tab.SetDrawTabCallback(&Parm);
    }

    // Make sure to turn redraw back on
    m_Tab.SetRedraw(TRUE);
    m_Tab.InvalidateRect(NULL, TRUE);

    // If you are not using the sheet/page classes, remove the call to InitializeTabControl.
    // Initialize tab control
    InitializeTabControl(0, &m_Tab, NULL);

    return FALSE;
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CSampleDlg::OnPaint() 
{
    if (IsIconic())
    {
        CPaintDC dc(this); // device context for painting

        SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

        // Center icon in client rectangle
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // Draw the icon
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CPaintDC dc(this); // device context for painting

        CSftTabsDialog::OnPaint();

        // draw the background bitmap
        CRect rect;
        GetClientRect(&rect);
        SftTabs_PaintTiledBitmap(dc.m_hDC, (HBITMAP) m_BgBitmap.m_hObject, 0, 0, &rect);
    }
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CSampleDlg::OnQueryDragIcon()
{
    return (HCURSOR) m_hIcon;
}

/*------------------------------------------------------------------------------*/
/* This sample code implements a drawing callback which calculates the size of  */
/* the tab label and paints the tab label for every other tab, as requested by  */
/* SftTabs/DLL.                                                                 */
/*------------------------------------------------------------------------------*/

// Helper function to translate system colors into RGB values

static COLORREF TrColor(COLORREF color, COLORREF colorDefault)
{
    if (color == SFTTABS_NOCOLOR)
        color = colorDefault;
    if (color & 0x80000000L)
        return GetSysColor((int) (color & 0xffff));
    else
        return color;
}

void CALLBACK CSampleDlg::DrawOneTabCallback(HWND hwnd, int iTab, SFTTABS_DWORD_PTR UserData, LPSFTTABS_DRAWINFO lpDrawInfo)
{
    CSampleDlg* PTHIS = (CSampleDlg*) UserData;
    ASSERT(PTHIS);
    PTHIS->DrawOneTab(iTab, lpDrawInfo);
}

void CSampleDlg::DrawOneTab(int iTab, LPSFTTABS_DRAWINFO lpDrawInfo)
{
    if (iTab == 1) { /* only handle the second tab */

        SFTTABS_TAB Tab;
        // get tab attributes
        m_Tab.GetTabInfo(iTab, &Tab);

        CDC dc;
        dc.Attach(lpDrawInfo->hDC);

        switch (lpDrawInfo->style) {
        case SFTTABS_DI_CALC: {
            // calculate the size of the label
            CFont* tFont = (CFont*) dc.SelectObject(lpDrawInfo->hFont);
            dc.DrawText(Tab.lpszText, -1, &lpDrawInfo->DrawRect, DT_CALCRECT|DT_SINGLELINE);
            // allow extra space for border
            ::InflateRect(&lpDrawInfo->DrawRect, 5, 5);
            break;
         }
        case SFTTABS_DI_PAINT: {
            // paint label
            CBrush brFill, brFrame;
            COLORREF color;
            int mode;
            // select the background color as defined for the tab
            if (lpDrawInfo->fActive)
                color = Tab.colorBgSel;
            else
                color = Tab.colorBg;
            // translate to real color (if using system colors) or use default
            // tab control color if no tab color defined
            color = TrColor(color, RGB(255,255,255)); // or lpDrawInfo->colorBg

            if (SftTabs_GetGDIPlusAvailable(m_Tab)) {
                // GDI+ is available
                if (lpDrawInfo->fHighlight)
                    SftTabs_DrawSelectionOutline(m_Tab, lpDrawInfo->hDC, &lpDrawInfo->DrawRect, 0xFFBF00L, 0xf3f3e4L, 0xFFFFFFL, 0xDAC583L);
                else
                    SftTabs_DrawSelectionOutline(m_Tab, lpDrawInfo->hDC, &lpDrawInfo->DrawRect, 0xFFBF00L, 0xF2F0C8L, 0xFFFFFFL, 0xE6D8ADL);
            } else {
                // GDI+ is not available
                // If the tab control has the input focus, use a solid background
                if (lpDrawInfo->fFocus)
                    brFill.CreateSolidBrush(color);
                else
                    brFill.CreateHatchBrush(HS_FDIAGONAL, color);
                dc.FillRect(&lpDrawInfo->DrawRect, &brFill);

                if (lpDrawInfo->fHighlight) {
                    // use flyby color, because tab is highlighted
                    color = TrColor(Tab.colorFlybyFg, RGB(0,0,128));
                    brFrame.CreateSolidBrush(color);
                    // draw double frame
                    dc.FrameRect(&lpDrawInfo->DrawRect, &brFrame);
                    ::InflateRect(&lpDrawInfo->DrawRect, -1, -1);
                    dc.FrameRect(&lpDrawInfo->DrawRect, &brFrame);
                } else {
                    // select the foreground color as defined for the tab
                    if (lpDrawInfo->fActive)
                        color = Tab.colorFgSel;
                    else
                        color = Tab.colorFg;
                    // translate to real color (if using system colors) or use default
                    // tab control color if no tab color defined
                    color = TrColor(color, lpDrawInfo->colorFg);
                    // frame the area
                    brFrame.CreateSolidBrush(TrColor(lpDrawInfo->fActive ? Tab.colorFgSel : Tab.colorFg, lpDrawInfo->colorFg));
                    dc.FrameRect(&lpDrawInfo->DrawRect, &brFrame);
                }
            }
            // Use the foreground color to draw the text
            if (lpDrawInfo->fActive)
                color = Tab.colorFgSel;
            else
                color = Tab.colorFg;
            color = TrColor(color, lpDrawInfo->colorFg);
            ::InflateRect(&lpDrawInfo->DrawRect, -1, -1);
            CFont* tFont = (CFont*) dc.SelectObject(lpDrawInfo->hFont);
            mode = dc.SetBkMode(TRANSPARENT);
            dc.DrawText(Tab.lpszText, -1, &lpDrawInfo->DrawRect, DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_WORD_ELLIPSIS);
            dc.SetBkMode(mode);

            // Draw a focus ring
            if (lpDrawInfo->fFocus) {
                if (SftTabs_GetGDIPlusAvailable(m_Tab)) {
                    RECT trect = lpDrawInfo->DrawRect;
                    InflateRect(&trect, -2, -2);
                    dc.DrawFocusRect(&trect);
                } else
                    dc.DrawFocusRect(&lpDrawInfo->DrawRect);
            }
            break;
         }
        }
        dc.Detach();
    }
}

Last Updated 08/13/2020 - (email)
© 2024 Softel vdm, Inc.